@arg = @ARGV;
#opciones de consulta
$opciones_consulta = $arg[0];

$ambiente_inicializado=$ENV{'GRUPO'};

#Me fijo que este inicializado el ambiente.
if($ambiente_inicializado eq "Y"){ 
  die "El ambiente no fue corrrectamente inicializado. Por favor ejecute IniciarT para realizarlo. \n";
}

#Ayuda.
#Al ejecutar el comando con el parámetro -h se despliega la ayuda del mismo.
if(grep(/^-h$/,$opciones_consulta)>0){
	print "\n\n------------------------------------Ayuda---------------------------------------------------------------- \n\n";
	print "Para realizar una consulta deberá ingresar los parámetros -c, -ce o -e seguido de\n";
	print "-arch especificando los archivos de entrada que se procesarán separados por comas seguido de \n";
	print "-suc especificando los ids de sucursales separados por comas seguido de \n";
	print "-cl especificando los ids de clientes separados por comas, y finalmente ingresando \n";
	print "-descrItem especificando las descripciones de los items separados por comas para realizar la consulta.\n";
	print "----------------------------------------------------------------------------------------------------------\n\n";
	print "La selección de archivos de entrada se hace agregando la siguiente sintaxis\n";
	print "a la llamada:\n\n";
	print "-arch archivo1,archivo2,archivo3,...,archivoN \n";
	print "Este parámetro acepta mayúsculas y minúsculas.\n\n";
	print "Para ingresar todos los archivos se puede ingresar el caracter \\\*\ como comodin\n";
	print "(indicando que puede haber de cero a N ocurrencias de cualquier caracter).\n\n";
	print "En caso de no seleccionar archivos (es decir, no ingresar a \"-arch\" los valores), se emplearán todos.\n\n";
	print "----------------------------------------------------------------------------------------------------------\n\n";
	print "Las selecciones de sucursales, clientes y descripciones de items se realizan con la siguiente \n";
	print "sintaxis (respectivamente):\n\n";
	print "-suc suc1,suc2,...,sucN \n\n";
	print "-cl idCliente1,idCliente2,...,idClienteN \n\n";
	print "-descrItem descrItem1,descrItem2,...,descrItemN o ingresando un sub string, por ejemplo\n";
	print "se puede ingresar la descripción completa \"Plan Comercial Cablemodem (Residencial)\" o simplemente \"Residencial\".\n";
	print "Este parámetro acepta mayúsculas y minúsculas.\n\n";
	print "Si cualquiera de las sucursales, clientes o descripciones de items es \\\*\ se tomarán todas las \n";
	print "existentes, al igual que si no se especifica alguno de los parámetros.\n\n";
	print "----------------------------------------------------------------------------------------------------------\n\n";
	print "Las consultas generarán un reporte el cual se motrará en:\n";
	print "-c pantalla.\n";
	print "-ce pantalla y en un archivo cuyo nombre será el número de secuencia mayor.\n";
	print "-e en un archivo cuyo nombre será el número de secuencia mayor.\n\n";
	print "----------------------------------------------------------------------------------------------------------\n\n";
	print "Deberán especificarse todos los parametros para realizar la consulta, aunque no se ingresen valores en ellos,\n";
	print "por ejemplo: perl ListarT.pl -c -arch -suc -descrItem -cl efectuaría la consulta sobre todos los archivos de parque instalado";
	print "para todas las sucursales, todos los items y todos los clientes de esos archivos.\n\n";
	print "----------------------------------------------------------------------------------------------------------\n\n";
	die "FIN DEL AYUDA\n";
}
#/Ayuda.

$grupo=$ENV{'GRUPO'};

if($opciones_consulta ne "-c" && $opciones_consulta ne "-e" && $opciones_consulta ne "-ce"){
	die "Debe ingresar las opciones -c -e o -ce para realizar las consultas. Ingrese -h para ver la ayuda del comando. \n";
	
}

#Entradas.
#Con el parámetro -arch se agregan a un arreglo (@archivosEntradaUsu) los nombre de archivo ingresados por el usuario (estos archivos podrían tener el caracter * como comodín), en caso contrario se agrega el caracter * como uno de los elementos.
if (grep(/^-arch$/,@arg)>0){
	
	my $cont = 0;
	foreach $exprRegular(@arg){
               if(grep(/^-arch$/,$exprRegular)>0){
		   			 my @argArch=@arg[$cont+1..$#arg];
		   			 
		   			 my $argumentosArch="";
		   			 foreach my $paramArch(@argArch){
		   			 	
		   			 	if(!(((grep(/^\*$/,$paramArch)>0)||grep(/^-suc$/,$paramArch)>0)||(grep(/^-cl$/,$paramArch)>0)||(grep(/^-descrItem$/,$paramArch)))){
		   			 			$argumentosArch=$argumentosArch.$paramArch." ";
		   			 	}else{
		   			 		last;
		   			 	}
		   			 }
		    
          			 if($argumentosArch eq ""){
          			 	push(@archivosEntradaUsu,"*");
          			 }else{
          			 	chop $argumentosArch;
          			 	$argumentosArch=uc($argumentosArch);
          			 	@archivosEntradaUsu= split(",",$argumentosArch);
          			 }
									last;   
		  							
		   					   			
	       		}		
	   $cont=$cont+1;
	}
}else{
	die "Debe ingresar seguido de las opciones -c -e o -ce para realizar las consultas, -arch seguido de los nombres de archivos de producto de parque instalado. Ingrese -h para ver la ayuda del comando. \n";
	
}

#Se colocan en un arreglo (@archivosEnDir) todos los archivos del directorio de parque instalado
$dir= "$grupo/parque_instalado/";

opendir(DIR,$dir) || die "Error al abrir el directorio $dir \n";

@archivosEnDir=readdir(DIR);

#Si alguno de los elementos del arreglo @archivosEntradaUsu es * o vacio se toman como entrada para el comando (arreglo @archivosEntrada) todos los archivos del
#arreglo @archivosEnDir.

if(grep(/^\*$/,@archivosEntradaUsu)>0){
	@archivosEntrada=@archivosEnDir;	
}
#En caso contrario, se comparan los nombres de archivo ingresados por el usuario con los del directorio, y se ingresan al arreglo de entrada los
#coincidentes.
else{
	foreach my $archDir(@archivosEnDir){
		
		my $archDirMay = uc($archDir);
		
		foreach my $archivoCoincidente(@archivosEntradaUsu){
			
			if(grep(/^$archivoCoincidente$/,$archDirMay)>0){
				push(@archivosEntrada,$archDir);
				last;	
			}
		}		
			
	}
}
#/Entradas.


#Sucursales.
#Si no se ingreso en el parámetro -suc ningún valor, se ingresa al arreglo de sucursales un caracter *.
if (grep(/^-suc$/,@arg)>0){
	
	my $cont = 0;
	foreach $exprRegular(@arg){
               if(grep(/^-suc$/,$exprRegular)>0){
		   			 my @argSuc=@arg[$cont+1..$#arg];
		   			 
		   			 my $argumentosSuc="";
		   			 foreach my $paramSuc(@argSuc){
		   			 	
		   			 	if(!(((grep(/^\*$/,$paramSuc)>0)||grep(/^-arch$/,$paramSuc)>0)||(grep(/^-cl$/,$paramSuc)>0)||(grep(/^-descrItem$/,$paramSuc)))){
		   			 			$argumentosSuc=$argumentosSuc.$paramSuc." ";
		   			 	}else{
		   			 		last;
		   			 	}
		   			 }
		    
          			 if($argumentosSuc eq ""){
          			 	push(@sucursalesUsu,"*");
          			 }else{
          			 	chop $argumentosSuc;
          			 	@sucursalesUsu= split(",",$argumentosSuc);
          			 }
				
									last;   
		  							
		   					   			
	       		}		
	   $cont=$cont+1;
	}
}else{
	die "Debe ingresar seguido de las opciones -c -e o -ce para realizar las consultas y -arch junto con los nombres de archivos de producto de parque instalado el parámetro -suc junto con los ids de sucursales. Ingrese -h para ver la ayuda del comando. \n";
	
}
#/Sucursales.

#Clientes.
#Si no se especificó el parámetro -cl, se ingresa al arreglo de clientes un caracter *.
#Si se especificó, se inserta al arreglo cada una de las clientes ingresados a continuación del parámetro.
if (grep(/^-cl$/,@arg)>0){
	
	my $cont = 0;
	foreach $exprRegular(@arg){
               if(grep(/^-cl$/,$exprRegular)>0){
		   			 my @argCl=@arg[$cont+1..$#arg];
		   			 
		   			 my $argumentosCl="";
		   			 foreach my $paramCl(@argCl){
		   			 	
		   			 	if(!(((grep(/^\*$/,$paramCl)>0)||grep(/^-arch$/,$paramCl)>0)||(grep(/^-suc$/,$paramCl)>0)||(grep(/^-descrItem$/,$paramCl)))){
		   			 			$argumentosCl=$argumentosCl.$paramCl." ";
		   			 	}else{
		   			 		last;
		   			 	}
		   			 }
		    
          			 if($argumentosCl eq ""){
          			 	push(@clientesUsu,"*");
          			 }else{
          			 	chop $argumentosCl;
          			 	@clientesUsu= split(",",$argumentosCl);
          			 }
				
									last;   
		  							
		   					   			
	       		}		
	   $cont=$cont+1;
	}
}else{
	die "Debe ingresar seguido de las opciones -c -e o -ce para realizar las consultas, y -arch junto con los nombres de archivos de producto de parque instalado seguido del parámetro -suc con los ids de sucursales, el parámetro -cl seguido de los ids de clientes. Ingrese -h para ver la ayuda del comando. \n";
}
#/Clientes.

#Item.
#Si no se ingreso en el parámetro -descrItem ningún valor, se ingresa al arreglo de items un caracter *.
if (grep(/^-descrItem$/,@arg)>0){
	
	my $cont = 0;
	foreach $exprRegular(@arg){
               if(grep(/^-descrItem$/,$exprRegular)>0){
		   			 my @argDescrItem=@arg[$cont+1..$#arg];
		   			 
		   			 my $argumentosDescrItem="";
		   			 foreach my $paramDescrItem(@argDescrItem){
		   			 	if(!((grep(/^\*$/,$paramDescrItem)>0)||(grep(/^-arch$/,$paramDescrItem)>0)||(grep(/^-suc$/,$paramDescrItem)>0)||(grep(/^-cl$/,$paramDescrItem)))){
		   			 			$argumentosDescrItem=$argumentosDescrItem.$paramDescrItem." ";
		   			 	}else{
		   			 		last;
		   			 	}
		   			 }
		    
          			 if($argumentosDescrItem eq ""){
          			 	push(@descripcionItemUsu,"*");
          			 }else{
          			 	chop $argumentosDescrItem;
          			 	@descripcionItemUsu= split(",",$argumentosDescrItem);
          			 }
				
									last;   
		  							
		   					   			
	       		}		
	   $cont=$cont+1;
	}
}else{
	die "Debe ingresar seguido de las opciones -c -e o -ce para realizar las consultas, el parámetro -arch junto con los nombres de archivos de producto de parque instalado, y el parámetro -suc seguido de los ids de sucursales y del parámetro -cl seguido de los ids de clientes, el parámetro -descrItem seguido de las descripciones de los items. Ingrese -h para ver la ayuda del comando. \n";;
}
#/Item.

#Salida.
#Se busca un nombre de archivo disponible para poder usar como salida.
$secuencia=0;
$archivosalida="$ENV{'REPODIR'}/lpi.$secuencia";

while(-e $archivosalida)
{ 
	$secuencia++;
	$archivosalida="$ENV{'REPODIR'}/lpi.$secuencia";
}

#Si se ingresan las opciones -e o -ce, se abre la salida standard y se crea un archivo con el nombre lpi.<secuencia>. 
if(grep(/^-e$/,@ARGV)>0 or grep(/^-ce$/,@ARGV)>0){
	open(ARCHOUT,">>$archivosalida") || die "No se pudo abrir el archivo $archivosalida para generar el reporte \n";
}
#/Salida.

#A traves de los archivos de producto que se ingresan (archivos de parque instalado), se genera un hash poniendo como
#clave (nombreArchivo,idSucursal,idCliente). El nombre de archivo corresponde al nombre del tipo de producto.
#El valor del hash será: descripción_item_cabecera (plan comercial),descripción_item_detalle (item)

#Proceso de archivos de parque instalado y generación del hash ("nombreArch,idSuc,IdCl","planComercial,Item")

foreach my $archivo (@archivosEntrada){
	open(ARCHIN,"$dir/$archivo")|| die "No se pudo abrir el archivo de parque instalado: $dir/$archivo \n";
	
	$cont_reg=0;
	while (<ARCHIN>) {
	
		@campo_parque = split(",", $_);
				
		my $descrItemValido=0;
		
		if(grep(/^\*$/,@descripcionItemUsu)>0){
			$descrItemValido=1;		
		}else{
			my $campo_mayus = uc($campo_parque[2]);
     			
			foreach my $descripcionItem (@descripcionItemUsu){
				
				$descripcionItem = uc($descripcionItem);
								
				if($campo_mayus =~ m/\($descripcionItem\)/){
				    	$descrItemValido=1;
					last;			
				}
			}
		}
		
						
		if((grep(/^$campo_parque[0]$/,@sucursalesUsu)>0 || grep(/^\*$/,@sucursalesUsu)>0) and
		   (grep(/^$campo_parque[1]$/,@clientesUsu)>0 || grep(/^\*$/,@clientesUsu)>0) and 
		   ($descrItemValido==1)){
				
			$key_parque="$archivo,$campo_parque[0],$campo_parque[1]";
			
			$hashCantProductosPorCliente{$campo_parque[1]}=$hashCantProductosPorCliente{$campo_parque[1]}+1;
			$hashCantClientesPorSucursal{$campo_parque[0]}=$hashCantClientesPorSucursal{$campo_parque[0]}+1;
			
			push(@productosConsultaMaestroAux,$archivo);
			push(@sucursalesConsultaMaestroAux,$campo_parque[0]);
			push(@clientesConsultaMaestroAux,$campo_parque[1]);
	
			$valor_parque="$campo_parque[2],$campo_parque[3]";
						
			$hash_parque{$key_parque}=$valor_parque;
		
		}
		$cont_reg++;
	}
	close(ARCHIN);
}
#\Termina proceso de archivos de parque instalado y generación del hash ("nombreArch,idSuc,IdCl","planComercial,Item").

#Elimino elementos repetidos de cada array
my %visto = ();
my @productosConsultaMaestro = grep { ! $visto{ $_ }++ } @productosConsultaMaestroAux; 

my %visto2 = ();
my @sucursalesConsultaMaestro = grep { ! $visto2{ $_ }++ } @sucursalesConsultaMaestroAux; 

my %visto3 = ();
my @clientesConsultaMaestro = grep { ! $visto3{ $_ }++ } @clientesConsultaMaestroAux; 
#\Finaliza la eliminación de elementos repetidos

#Proceso el arch maestro de sucursales y armo un hash ("idSucursal,Branch_Name") 
$dirMaestro= "$ENV{'MAEDIR'}";
open(ARCH_SUC,"$dirMaestro/sucu.mae")||die "No se pudo abrir el archivo maestro: $dirMaestro/sucu.mae \n";
while(<ARCH_SUC>){
	$encontrado=0;
	@campo_suc = split(",", $_);
	$sucAux=$campo_suc[2];
	
	$cont=0;
	
	foreach $sucursalAux(@sucursalesConsultaMaestro){
		if($sucursalAux==$sucAux){
			$encontrado=1;
			delete $sucursalesConsultaMaestro[$cont];
			last;
		}
		$cont=$cont+1;	
	}
	
	if($encontrado==1){
		$hash_suc{$sucAux}=$campo_suc[3];
	}
	
	if($#sucursalesConsultaMaestro==-1){
		last;
	}
}
close(ARCH_SUC);
#\Fin del proceso del archivo maestro de sucursales y del armado del hash.

#Proceso el arch maestro de clientes y armo un hash ("idSucursal,Branch_Name") 
$dirMaestro= "$grupo/mae/";
open(ARCH_CLI,"$dirMaestro/cli.mae") || die "No se pudo abrir el archivo maestro: $dirMaestro/cli.mae \n";
while(<ARCH_CLI>){
	$encontrado=0;
	@campo_cli = split(";", $_);
	$cliAux=$campo_cli[0];
	
	$cont=0;
	
	foreach $clienteAux (@clientesConsultaMaestro){
		if($clienteAux==$cliAux){
			$encontrado=1;
			delete $clientesConsultaMaestro[$cont];
			last;
		}
		$cont=$cont+1;	
	}
	
	if($encontrado==1){
		$hash_cli{$cliAux}=$campo_cli[2];
	}
	
	
	
	if($#clientesConsultaMaestro==-1){
		last;
	}
}
close(ARCH_CLI);
#\Fin del proceso del archivo maestro de clientes y del armado del hash.

#Proceso la consulta
if($opciones_consulta ne "-e"){
	print "\nGENERANDO EL REPORTE CON LOS PARAMETROS @ARGV \n";
	print "-----------------------------------------------------------------------------------------------------------------\n";
	print "Id Sucursal \|\| Nombre Sucursal \|\| Id Cliente \|\| Apellido o Razón Social \|\| Tipo de producto \|\| Plan Comercial \|\| Item \n";
	print "-----------------------------------------------------------------------------------------------------------------\n\n";
}	

if(($opciones_consulta eq "-ce") or ($opciones_consulta eq "-e")){
	print ARCHOUT "REPORTE GENERADO CON LOS PARAMETROS PRODUCTOS: @archivosEntradaUsu \| SUCURSALES: @sucursalesUsu \| CLIENTES: @clientesUsu \| DESCRIPCION_ITEM: @descripcionItemUsu \n\n";
	print ARCHOUT "Id Sucursal \|\| Nombre Sucursal \|\| Id Cliente \|\| Apellido o Razón Social \|\| Tipo de producto \|\| Plan Comercial \|\| Item \n\n";
	print ARCHOUT "-----------------------------------------------------------------------------------------------------------------\n";
}
	
	
foreach my $keyAux (sort keys(%hash_parque ))  {
   my @prod_suc_cli= split(",",$keyAux); 
   my @planComercial_Item = split(",",$hash_parque{$keyAux}); 
   my $var_id_suc=$prod_suc_cli[1];
   my $var_nom_suc=$hash_suc{$prod_suc_cli[1]};
   my $var_id_cli=$prod_suc_cli[2];
   my $var_ap_raz_soc=$hash_cli{$prod_suc_cli[2]};
   my $var_tipoProd=$prod_suc_cli[0];
   my $var_planComercial=$planComercial_Item[0];
   my $var_item=$planComercial_Item[1];
   
   if($opciones_consulta ne "-e"){
   	print "$var_id_suc \|\| $var_nom_suc \|\| $var_id_cli \|\| $var_ap_raz_soc \|\| $var_tipoProd \|\| $var_planComercial \|\| $var_item\n";  
   	print "-----------------------------------------------------------------------------------------------------------------\n";
   }
   
   if(($opciones_consulta eq "-ce") or ($opciones_consulta eq "-e")){
   	print ARCHOUT "\n$var_id_suc \|\| $var_nom_suc \|\| $var_id_cli \|\| $var_ap_raz_soc \|\| $var_tipoProd \|\| $var_planComercial \|\| $var_item\n\n";  
   	print ARCHOUT "-----------------------------------------------------------------------------------------------------------------\n";
   }
	   
 }

@keysHashCantProductosPorCliente=keys(%hashCantProductosPorCliente);
$tamanioClientes=$#keysHashCantProductosPorCliente+1;

if($opciones_consulta ne "-e"){
	print "\n\nTOTAL DE CLIENTES CON PRODUCTOS @archivosEntrada INGRESADOS EN LA CONSULTA, INSTALADOS: $tamanioClientes\n";
	print "-----------------------------------------------------------------------------------------------------------------\n";
   	print "\n\nSUBTOTAL DE PRODUCTOS SOLICITADOS POR LOS CLIENTES\n";
	print "-----------------------------------------------------------------------------------------------------------------\n";
	foreach my $key_clienteSubTotal (sort { $a <=> $b } (keys (%hashCantProductosPorCliente))){
		print "Cliente id $key_clienteSubTotal con $hashCantProductosPorCliente{$key_clienteSubTotal} productos\n";
		print "-----------------------------------------------------------------------------------------------------------------\n";	
	}
	print "\n\nSUBTOTAL DE CLIENTES POR SUCURSAL\n";
	print "-----------------------------------------------------------------------------------------------------------------\n";
	foreach my $key_sucuSubTotal (sort { $a <=> $b } (keys (%hashCantClientesPorSucursal))){
		print "Sucursal id $key_sucuSubTotal con $hashCantClientesPorSucursal{$key_sucuSubTotal} clientes\n";
		print "-----------------------------------------------------------------------------------------------------------------\n";	
	}
}

if(($opciones_consulta eq "-e") or ($opciones_consulta eq "-ce")){
	
	print ARCHOUT "\n\nTOTAL DE CLIENTES CON PRODUCTOS @archivosEntrada INGRESADOS EN LA CONSULTA, INSTALADOS: $tamanioClientes\n";
	print ARCHOUT "-----------------------------------------------------------------------------------------------------------------\n";
	print ARCHOUT "\n\nSUBTOTAL DE PRODUCTOS SOLICITADOS POR LOS CLIENTES\n";
	print ARCHOUT "-----------------------------------------------------------------------------------------------------------------\n";
	foreach my $key_clienteSubTotal (sort { $a <=> $b } (keys (%hashCantProductosPorCliente))){
		print ARCHOUT "Cliente id $key_clienteSubTotal con $hashCantProductosPorCliente{$key_clienteSubTotal} productos\n";
		print ARCHOUT "-----------------------------------------------------------------------------------------------------------------\n";	
	}
	print ARCHOUT "\n\nSUBTOTAL DE CLIENTES POR SUCURSAL\n";
	print ARCHOUT "-----------------------------------------------------------------------------------------------------------------\n";
	
	foreach my $key_sucuSubTotal (sort { $a <=> $b }  (keys(%hashCantClientesPorSucursal))){
		print ARCHOUT "Sucursal id $key_sucuSubTotal con $hashCantClientesPorSucursal{$key_sucuSubTotal} clientes\n";
		print ARCHOUT "-----------------------------------------------------------------------------------------------------------------\n";	
	}
}

if(($opciones_consulta eq "-ce") or ($opciones_consulta eq "-e")){
	close(ARCHOUT);
}
#\Fin del proceso de consulta.




